\documentclass[10.5pt, a4paper]{article}

\usepackage{xeCJK}
\newCJKfontfamily{\heiti}[AutoFakeBold={3.17}]{SimHei}

\usepackage{geometry}
\geometry{
    left = 0.6in,
    right = 0.6in,
    top = 0.8in,
    bottom = 1.0in
}
\usepackage{amssymb,amsbsy,amsmath,xcolor,mathrsfs,graphicx}
\usepackage{listings}
\usepackage{tasks}
\settasks{
    label = \Alph*. ,
    label-width = 13pt
}

\renewcommand{\title}[3]{
    \begin{center}
        \Large\heiti #1~年~#2~月 Python~#3级考试
    \end{center}
}
\newcommand{\TimeAndName}[1]{
    \begin{center}
        考试时间:~#1~ 分钟 \qquad\qquad\qquad\qquad 姓名:\underline{\quad\quad\quad\quad}
    \end{center}
}

\begin{document}
    \lstset{
        language = python,
        keywordstyle = \color{orange}\bfseries,
        emph = {print,bool,chr,ord,sorted,float,type,oct,hex,abs,sum,len,int,open,list,map,str,range,min,max,input,eval},
        emphstyle = \color{purple}\bfseries,
        showspaces = false,
        basicstyle = \ttfamily,
        morekeywords = {True,False}
    }

    \title{2021}{12}{二}
    
    \TimeAndName{60}
    
    \vspace{1cm}
    {\noindent\heiti 第一部分、单选题(共 25 题,每题 2 分,共50分.)}

    \begin{enumerate}
        % 1
        \item 执行以下程序，运行结果是？(\qquad)
        \begin{lstlisting}
            a = [33, 55, 22, 77]
            a.sort()
            for i in a:
                print(i)
        \end{lstlisting}
        \begin{tasks}(4)
            \task 33\ 55\ 22\ 77
            \task 22\ 33\ 55\ 77
            \task 55\ 33\ 22\ 77
            \task 77\ 55\ 33\ 22
        \end{tasks}
    
        % 2
        \item 运行以下程序，当输入 12 时，输出结果为？(\qquad)
        \begin{lstlisting}
            a = eval(input("年龄:"))
            if a > 10:
                b = 30
            else
                b = 15
            print("票价:", b)
        \end{lstlisting}
        \begin{tasks}(4)
            \task 票价:12
            \task 票价:15
            \task 票价:30
            \task 票价:10
        \end{tasks}

        % 3
        \item 执行以下程序，运行结果是？(\qquad)
        \begin{lstlisting}
            a = {'gj':'china', 'nl':12, 'xb':'女'}
            a['nl'] = 11
            del a['gj']
            a['xm'] = 'xxs'
            print(a)
        \end{lstlisting}
        \begin{tasks}(2)
            \task \lstinline!\{'gj':china, 'nl':11, 'xb':'女'\}!
            \task \lstinline!\{'nl':11, 'xb':'女'\}!
            \task \lstinline!\{'nl':11, 'xb':'女', 'xm':'xxs'\}!
            \task \lstinline!\{'nl':12, 'xm':'xxs', xb':'女'\}!
        \end{tasks}

        % 4
        \item 执行以下程序，运行结果是？(\qquad)
        \begin{lstlisting}
            l = ['i', 'love', 'you', '!']
            l = '.'.join(l)
            l = l.split('.')
            l = ' '.join(l)
            print(l)
        \end{lstlisting}
        \begin{tasks}(2)
            \task \lstinline{iloveyou!}
            \task \lstinline{i.love.you!}
            \task \lstinline{i love you !}
            \task \lstinline{['i', 'love', 'you', '!']}
        \end{tasks}

        % 5
        \item 以下程序的功能是?(\qquad)
        \begin{lstlisting}
            a = 0
            for i in range(1, 100):
                if (i % 2 == 0):
                    a = a + 1
            print(a)
        \end{lstlisting}
        \begin{tasks}
            \task 计算并输出 100 以内(不含 0 和 100) 所有数字的和
            \task 计算并输出 1 - 100 所有数字的和，输出 5050
            \task 统计并输出 100 以内(不含 0 和 100) 偶数个数，输出 50
            \task 统计并输出 100 以内(不含 0 和 100) 偶数个数，输出49
        \end{tasks}

        % 6
        \item 以下程序执行后的结果是？(\qquad)
        \begin{lstlisting}
            s = 'Kevin likes English.'
            new = ''
            for i in range(len(s)):
                if i % 3 == 0:
                    new += s[i]
            print(new)
        \end{lstlisting}
        \begin{tasks}(4)
            \task \lstinline{enisni.}
            \task \lstinline{KileEls}
            \task \lstinline{KvnlksEgih}
            \task \lstinline{KileElh}
        \end{tasks}

        % 7
        \item 对于元组 \lstinline{tup = ('富强', '民主', '文明', '和谐', '爱国')} 操作正确的是？(\qquad)
        \begin{tasks}(2)
            \task \lstinline{tup[2:4:2] = ('敬业')}
            \task \lstinline{tup[4] = '敬业'}
            \task \lstinline{del tup[4]}
            \task \lstinline{tup * 3}
        \end{tasks}

        % 8
        \item 下列程序的第四行横线处输入哪个选项中的代码不能打印九九乘法表？(\qquad)
        \begin{lstlisting}
            for i in range(1, 10): 
                for j in range(1, 10): 
                    if j <= i:  
                        __________
                print("")
        \end{lstlisting}
        \begin{tasks}
            \task \lstinline!print("{}*{}={}".format(j, i, i*j) ,end=" ")!
            \task \lstinline!print("\%d*\%d=\%d" \% (j, i, i*j) ,end=" ")!
            \task \lstinline!print(j, '*', i, '=', i*j, end=" ")!
            \task \lstinline!print("{}*{}={}".format({j * i = {i * j}}) ,end=" ")!
        \end{tasks}

        % 9
        \item 下面的语句哪个会无限循环执行下去？(\qquad)
        \begin{tasks}(4)
            \task \lstinline!for a in range(10):!\\
            \lstinline!\ \ \ \ print(a)!

            \task \lstinline!a = 1!\\
            \lstinline!while True:!\\
            \lstinline!\ \ \ \ print(a)!\\
            \lstinline!\ \ \ \ if a == 3:!\\
            \lstinline!\ \ \ \ \ \ \ \ break!\\
            \lstinline!\ \ \ \ a = a + 1!

            \task \lstinline!a = 1!\\
            \lstinline!while True:!\\
            \lstinline!\ \ \ \ print(a)!\\
            \lstinline!\ \ \ \ if a == 3:!\\
            \lstinline!\ \ \ \ \ \ \ \ continue!\\
            \lstinline!\ \ \ \ a = a + 1!

            \task \lstinline!a = [1, 0, 2]!\\
            \lstinline!for i in a:!\\
            \lstinline!\ \ \ \ if not i:!\\
            \lstinline!\ \ \ \ \ \ \ \ continue!\\
            \lstinline!\ \ \ \ print(i)!
        \end{tasks}

        % 10
        \item  某商场促销打折，打折规定如下：消费 500 元以内的打 8.8 折；满 500 元(含 500) 的打 8 折，满 1000 元及以上的打 7 折. 要编程解决该问题，需要用到的控制语句是？(\qquad)
        \begin{tasks}(4)
            \task 赋值语句
            \task 选择(分支)结构语句
            \task 循环结构语句
            \task 输入输出语句
        \end{tasks}

        % 11
        \item 以下语句不能创建字典的是？(\qquad)
        \begin{tasks}(4)
            \task \lstinline!dic={}!
            \task \lstinline!dic={12:34}!
            \task \lstinline!dic={[12]:[34]}!
            \task \lstinline!dic={(12):(34)}!
        \end{tasks}

        % 12
        \item 执行下列代码，输出的结果是？(\qquad)
        \begin{lstlisting}
            stu = {'202101':'小明', '202102':'小红', '202103':'小丽'}
            print(len(stu))
        \end{lstlisting}
        \begin{tasks}(4)
            \task 0
            \task 1
            \task 3
            \task 6
        \end{tasks}

        % 13
        \item 下列语句中变量 \lstinline{i} 取值范围是 0 到 99 的是？(\qquad)
        \begin{tasks}(2)
            \task \lstinline!for i in range(101)!
            \task \lstinline!for i in range(1, 100)!
            \task \lstinline!for i in range(0, 101)!
            \task \lstinline!for i in range(100)!
        \end{tasks}

        \newpage
        % 14
        \item 执行下列程序的结果为？(\qquad)
        \begin{lstlisting}
            message1 = {'name':'Tom', 'age':14, 'city':'London'}
            for v in message1.values():
                print(v, end='')
        \end{lstlisting}
        \begin{tasks}(4)
            \task \lstinline!Tom14London!
            \task \lstinline!nameageLondon!
            \task \lstinline!name:Tom!
            \task \lstinline!Tom!
        \end{tasks}
        
        % \newpage
        % 15
        \item 下面代码运行的结果是？(\qquad)
        \begin{lstlisting}
            tup1 = ('中国', '电子学会', 1997, 2000)
            tup2 = (1, 2, 3, 4, 5, 6, 7)
            print(tup1[-1], tup2[1:5])
        \end{lstlisting}
        \begin{tasks}(2)
            \task \lstinline!2000 (2, 3, 4, 5)!
            \task \lstinline!2000 (2, 3, 4, 5, 6)!
            \task \lstinline!(2000 (2, 3, 4, 5))!
            \task \lstinline!1997 (1, 2, 3, 4, 5)!
        \end{tasks}

        % 16
        \item 以下代码的输出结果是？(\qquad)
        \begin{lstlisting}
            ls = [[1, 2, 3], 'python', [[4, 5, 'ABC'], 6], [7, 8]]
            print(ls[2][1])
        \end{lstlisting}
        \begin{tasks}(4)
            \task 5
            \task p
            \task 4
            \task 6
        \end{tasks}

        % 17
        \item 执行以下代码的结果是？(\qquad)
        \begin{lstlisting}
            name = ['Amir', 'Betty', 'Chales', 'Tao']
            name.index('Edward')
        \end{lstlisting}
        \begin{tasks}(4)
            \task -1
            \task 0
            \task 4
            \task 异常报错
        \end{tasks}

        % 18
        \item  下面程序的输出结果是？(\qquad)
        \begin{lstlisting}
            a = [[1, 2, 3],[4, 5, 6]]
            a.sort(reverse=True)
            print(a)
        \end{lstlisting}
        \begin{tasks}(2)
            \task \lstinline![[4, 5, 6], [1, 2, 3]]!
            \task \lstinline![6, 5, 4], [3, 2, 1]!
            \task \lstinline![[6, 5, 4], [3, 2, 1]]!
            \task \lstinline![4, 5, 6], [1, 2, 3]!
        \end{tasks}

        % 19
        \item 已知 \lstinline!a = list("zhangsan")!，执行了 \lstinline!a[1:7:2]! 后结果是？(\qquad)
        \begin{tasks}(2)
            \task \lstinline!['h', 'a', 'n', 'g', 's', 'a', 'n']!
            \task \lstinline!['z', 'h', 'a', 'n', 'g', 's', 'a']!
            \task \lstinline!['h', 'a', 'n', 'g', 's', 'a']!
            \task \lstinline!['h', 'n', 's']!
        \end{tasks}

        % 20
        \item 已知 \lstinline!a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]!，执行 \lstinline!del a[1:]! 后，\lstinline!a! 的结果是什么？(\qquad)
        \begin{tasks}(2)
            \task \lstinline![0, 1, 2, 3, 4, 5, 6, 7, 8]!
            \task \lstinline![1, 2, 3, 4, 5, 6, 7, 8, 9]!
            \task \lstinline![0]!
            \task \lstinline![0, 1]!
        \end{tasks}

        % 21
        \item 下列哪一个 Python 列表的创建是错误的？(\qquad)
        \begin{tasks}(2)
            \task \lstinline!l = [1, 3.14, 'laowang', [1, 2]]!
            \task \lstinline!l = [1, 3.14, laowang, [1, 2]]!
            \task \lstinline!l = [1, 3.14, "laowang", (1, 2)]!
            \task \lstinline!l = []!
        \end{tasks}

        % 22
        \item 下列关于 Python 列表的表达正确的是？(\qquad)
        \begin{tasks}
            \task Python 列表是包含 0 个或者多个对象引用的有序序列
            \task Python 列表用小括号 () 表示
            \task 列表的长度是不可变的
            \task Python 列表的元素间用顿号、隔开
        \end{tasks}

        % 23
        \item 已知列表 \lstinline!lis = ['a', 'bc', 'def']!，则执行 \lstinline!print(len(lis))! 语句输出的结果是？(\qquad)
        \begin{tasks}(4)
            \task 3
            \task 4
            \task 5
            \task 6
        \end{tasks}

        % \newpage
        % 24
        \item 在 Python 中，当列表需要动态添加元素时，使用下列哪个方法将一个新的元素添加到列表的尾部？(\qquad)
        \begin{tasks}(4)
            \task \lstinline!append()!
            \task \lstinline!del()!
            \task \lstinline!sort()!
            \task \lstinline!sorted()!
        \end{tasks}

        % 25
        \item 已知 \lstinline!t1 = (2, 3), t2 = (4, 5, 6)!，那么 \lstinline!t2 + t1 * 2! 的结果是？(\qquad)
        \begin{tasks}(2)
            \task \lstinline!(2, 3, 2, 3, 4, 5, 6)!
            \task \lstinline!(4, 5, 6, 2, 3, 2, 3)!
            \task \lstinline!(2, 3, 4, 5, 6, 2, 3, 4, 5, 6)!
            \task \lstinline!(2, 3, 4, 5, 6)!
        \end{tasks}
    \end{enumerate}

    {\noindent\heiti 第二部分、判断题(共 10 题,每题 2 分,共20分.)}
    \begin{enumerate}
        \setcounter{enumi}{25}
        % 26
        \item 运行如下程序，运行结果为 \lstinline{hi lanxi!}(\qquad)
        \begin{lstlisting}
            s1 = 'hi'
            s2 = ' lanxi'
            s3 = '!'
            print(s1 + s2 + s3)
        \end{lstlisting}

        %27
        \item 在一段程序中，如果有 \lstinline!break!，就一定有 \lstinline!continue!.(\qquad)
        
        %28
        \item 字符串是可变的数据类型.(\qquad)
  
        %29
        \item \lstinline!while! 循环的判断条件可以是任何表达式，只有当表达式的值为 \lstinline!True! 的时候，才执行循环体.(\qquad)
        
        %30
        \item 只有列表可以转换为元组，字符串、字典都无法转换成元组.(\qquad)
        
        %31
        \item \lstinline![1, 2] in [1, 2, 3, 4, 5, 6]! 的结果为 \lstinline!True!.(\qquad)
        
        %32
        \item 凡是用 \lstinline!while! 语句编写的循环结构，都可以用 \lstinline!for! 语句实现.(\qquad)
        
        %33
        \item 执行下列代码后，运行结果是：\lstinline{Helloorld!}.(\qquad)
        \begin{lstlisting}
            for i in "HelloWorld!:
                if i == 'W':
                    break
                print(i, end="")
        \end{lstlisting}
        
        %34
        \item 字典是无序的.(\qquad)
        
        %35
        \item \lstinline!t2 = 1, 2, 3! 则 \lstinline!t2! 是 \lstinline!int! 类型数据.(\qquad)
    \end{enumerate}

    % \newpage
    {\noindent\heiti 第三部分、编程题(共 2 题,共30分.)}
    \begin{enumerate}
        \setcounter{enumi}{35}
        
        % 36
        \item 实现统计字符串中的单词和单词出现的次数：
        
        \begin{tasks}[label=\arabic*.]
            \task 统计的语句为：\lstinline!"to be or not to be that is a question"! (不含引号)
            \task 要求统计该句中出现的所有单词和其出现次数
            \task 使用字典进行输出，格式如下(注意：排列顺序可以不一致，但是统计次数要正确)

            \lstinline!\{'to':2, 'be':2, 'or':1, 'not':1, 'is':1, 'a':1, 'question':1, 'that':1\}!
        \end{tasks}
        \vfill

        %37
        \item 可以对任何一个自然数进行若干次运算，最终都可以变为 1:
        
        \begin{tasks}[label=\arabic*.]
            \task 若该数是偶数，则变为原数的一半；
            \task 若该数是奇数，则变为原数的 3 倍加 1；
            \task 重复(1)、(2)，直到该数变成 1.
        \end{tasks}
        编写程序实现如下功能：输入一个大于 1 的自然数， 计算按照上述方法最终变换为 1 共经过的变换数，并输出变换次数

        示列1：若输入自然数 8，则输出结果为：3. 【4，2，1】共 3 次变换

        示列2：若输入自然数 5，则输出结果为：5. 【16，8，4，2，1】共 5 次变换
    \end{enumerate}

    \newpage
    \begin{center}
        \Huge \heiti 参考答案
    \end{center}

        \begin{tasks}[label=\arabic*.](5)
            \task B
            \task C
            \task C
            \task C
            \task D

            \task D
            \task D
            \task D
            \task C
            \task B

            \task C
            \task C
            \task D
            \task A
            \task A

            \task D
            \task D
            \task A
            \task D
            \task C

            \task B
            \task A
            \task A
            \task A
            \task B

            \task $\checkmark$
            \task $\times$
            \task $\times$
            \task $\checkmark$
            \task $\times$

            \task $\times$
            \task $\times$
            \task $\times$
            \task $\checkmark$
            \task $\times$
        \end{tasks}

        \begin{enumerate}
            \setcounter{enumi}{35}
            \item 自行判分

            \item 自行判分
        \end{enumerate}
\end{document}